package com.ys.p5Coolections集合工具类;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 描述: Collection基础使用
 ** 1.数组、List和Set之间的转换
 *  * 1.1数组转化为List
 *  *    Integer[] arr = {11, 22, 33, 44, 55};  // 注意：此处数组必须是引用数据类型
 *  *    List<Integer> list = Arrays.asList(arr);
 *  * 1.2List转化为Set
 *  *    HashSet<String> set1 = new HashSet<>(list);
 *  *    TreeSet<String> set2 = new TreeSet<>(list);
 *  *    作用：可以实现List元素的除重操作！
 *  * 1.3Set转化为List
 *  *    ArrayList<String> list1 = new ArrayList<>(set);
 *  *    LinkedList<String> list2 = new LinkedList<>(set);
 *  * 2.Collections工具类型
 *  *    数组的工具类是Arrays类，List集合的工具类就是Collections类。
 *  * 2.1排序（sort）
 *  *   public static <T extends Comparable<? super T>> void sort(List<T> list)
 *  *       使用内部比较器，来实现List集合的排序操作
 *  *   public static <T> void sort(List<T> list, Comparator<? super T> c)
 *  *       使用完毕比较器，来实现List集合的排序操作
 *  * 2.2混排（shuffle）
 *  *   public static void shuffle(List<?> list)
 *  * 2.3反转（reverse）
 *  *   public static void reverse(List<?> list)
 *  * 2.4替换所有的元素（fill）
 *  *   public static <T> void fill(List<? super T> list, T obj)
 *  注意: 集合操作的是已经被初始化的过元素,默认值不操作
 * @author CodeYang
 * @version 2020/12/29 0:56
 */
public class Collection基础使用 {
    public static void main(String[] args) {

//        method01();
//        method02();

//        method03();
//        method04();
//        method05();
        method06();




    }

    /**
     * Collections 反转集合  根据添加顺序反转集合
     */
    private static void method06() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Collections.reverse(list);
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

    /**
     *Collections 填充-替换
     *  只能操作 已经添加进入集合的元素,如果是一个没有初始化的集合就没有操作,而且省略00开头
     *  002 -> 2
     */
    private static void method05() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Collections.fill(list,888);
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

    /**
     * 混排.
     */
    private static void method04() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Collections.shuffle(list);
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

    /**
     * Collections内部比较器的排序使用
     */
    private static void method03() {
        List<Student> list = new ArrayList<>();
        list.add(new Student("xue1",18));
        list.add(new Student("xue2",88));
        list.add(new Student("xue3",78));
        list.add(new Student("xue4",28));
        // 直接使用自定义类必须 实现内部比较器,因为会自动调用
        // 使用内部比较器的 年龄降序排序输出
        Collections.sort(list);
        for (Student student : list) {
            System.out.println(student);
        }
    }

    /**
     *  Coolection排序
     */
    private static void method02() {

        List<Student> list = new ArrayList<>();
        list.add(new Student("xue1",18));
        list.add(new Student("xue2",88));
        list.add(new Student("xue3",78));
        list.add(new Student("xue4",28));

        // 使用Collection 做集合,age的升序排序
        // 使用外部比较器
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        Iterator<Student> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    /**
     * 数组 转 List 转 Set  相互抓换
     */
    private static void method01() {
        // 1: 各类集合自己的转型
        // 1-1: 数组,基础数据要使用包装类 转 List
        Integer[] arr = {1,3,6,7,9,45,2,4,100};
        // 一般使用Arrays.asList()
        List<Integer> list = Arrays.asList(arr);
        for (Integer integer : list) {
            System.out.print(integer+"\t");
        }
        //1	3	6	7	9	45	2	4	100

        System.out.println("\n____________________");
        // 1-2-1 :List 转 Set
        //  转 HashSet 集合可以用于去重,因为key不能重复 可以存null ,但是无序
        HashSet<Integer> HashSet = new HashSet<>(list);
        Iterator<Integer> iterator = HashSet.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+"\t");
        }
        //1	2	3	4	100	6	7	9	45
        System.out.println("\n___________________");
        // 1-2-2: List 转 Set
        // 转为TreeMap 也可以去重,key不能重复,不能为null,但是有序
        // 这样 无序的 list 插入转换后,就可以有序了
        TreeSet<Integer> treeSet = new TreeSet<>(list);
        Iterator iterator1 = treeSet.iterator();
        while (iterator1.hasNext()){
            System.out.print(iterator1.next()+"\t");
        }
        //1	2	3	4	6	7	9	45	100
        //1-3 Set 转 List
        // 1-3-1Set 转为 ArrayList
        System.out.println("\n----------------------");
        ArrayList<Integer> arrayList = new ArrayList<>(HashSet);
        System.out.println(Arrays.toString(arrayList.toArray()));
        //[1, 2, 3, 4, 100, 6, 7, 9, 45] 无序
        System.out.println("\n--------------");
        ArrayList<Integer> arrayList2 = new ArrayList<>(treeSet);
        System.out.println(Arrays.toString(arrayList2.toArray()));
        //[1, 2, 3, 4, 6, 7, 9, 45, 100] treeMap 在转过来有序
        // 1-3-1Set 转为 LinkedList
        LinkedList<Integer> arrayList3 = new LinkedList<>(treeSet);
        System.out.println(Arrays.toString(arrayList3.toArray()));
        // [1, 2, 3, 4, 6, 7, 9, 45, 100] 转为 LinkedList 一样

    }
}

